from Cartao import Cartao
from Estabelecimento import Estabelecimento
from Nodo import Nodo


class Arvore:
    

    def __init__(self):        
        self.rootNode = None
       
    def insertNodeUnique(self, objeto):        
        if self.rootNode is None:#TESTA SE A ARVORE EH VAZIA   
            self.rootNode = Nodo(objeto)#RAIZ RECEBE O NODO CRIADO ATRAVEZ DO OBJETO 
            self.rootNode.setCor('preto')#MUDA A COR DA RAIZ
        else:                       
            node = Nodo(objeto)#CONSTROI O NODO
            self.rb_insert(node)
            

        #INSERE O NODO E DEIXA A ARVORE ORDENADA
    def rb_insert(self, node):
        x= self.rootNode        
        while x != None:
            y=x
            n= node.getData()
            m= x.getData()
            if n.numero < m.numero:
                x= x.getLeftNode()
            else:
                x= x.getRightNode()
        node.setFather(y)
        if y == None:
            self.rootNode= node
            n= node.getData()
            m= y.getData()
        elif n.numero < m.numero:
            y.setLeftNode(node)
        else:
            y.setRightNode(node)
        node.setLeftNode(None)
        node.setRightNode(None)
        self.rb_insert_fixup(node)


        #DEIXA A ARVORE COM TODAS AS PROPRIEDADES DE UMA VERMELHO E PRETO
    def rb_insert_fixup(self, node):
        p= node.getFather()
        while p.getCor == 'vermelho':
            if node.getFather() == a.getFather():
                y= aa.getRightNode()
                a= node.getFather()
                aa= a.getFather()
                direita= a.getRightNode()
                if y.getCor() == 'vermelho':
                    a.setCor('preto')
                    y.setCor('preto')
                    aa.setCor('vermelho')
                    node= aa
                    
                elif node == direita:
                    node= node.getFather()
                    self.left_rotate(node)
                    pai= node.getFather()
                    pai.setCor('preto')
                    avo= pai.getFather()
                    avo.setCor('vermelho')
                    self.right_rotate(avo)

            else:
                y= aa.getLeftNode()
                a= node.getFather()
                aa= a.getFather()
                esquerda= a.getLeftNode()
                if y.getCor() == 'vermelho':
                    a.setCor('preto')
                    y.setCor('preto')
                    aa.setCor('vermelho')
                    node= aa
                    
                elif node == esquerda:
                    node= node.getFather()
                    self.right_rotate(node)
                    pai= node.getFather()
                    pai.setCor('preto')
                    avo= pai.getFather()
                    avo.setCor('vermelho')
                    self.left_rotate(avo)
        self.rootNode.setCor('preto')
        


        #ROTATE PARA A ESQUERDA
    def left_rotate(self, x):
        y= x.getRightNode()
        esq= y.getLeftNode()
        x.setRightNode(esq)
        esq.setFather(x)
        px= x.getFather()
        y.setFather(px)
        if x.getFather == None:
            self.rootNode= y
        elif x == px.getLeftNode():
            px.setLeftNode(y)
        else:
            px.setRightNode(y)
        y.setLeftNode(x)
        x.setFather(y)


        #ROTATE PARA A DIREITA
    def right_rotate(self, x):
        y= x.getLeftNode()
        esq= y.getRightNode()
        x.setLeftNode(esq)
        esq.setFather(x)
        px= x.getFather()
        y.setFather(px)
        if x.getFather == None:
            self.rootNode= y
        elif x == px.getRightNode():
            px.setRightNode(y)
        else:
            px.setLeftNode(y)
        y.setRightNode(x)
        x.setFather(y)
                    
        #PESQUISA NA ARVORE O NODO E O RETORNA       
    def tree_Search(self, x, chave):
        if x is not None:
            objeto= x.getData()            
            if chave == int(objeto.numero):
                return x
            if chave < int(objeto.numero):
                return self.tree_Search(x.getLeftNode(), chave)
            else:
                return self.tree_Search(x.getRightNode(), chave)


        #PESQUISA O NODO E FAZ AS MODIFICACOES DA COMPRA
    def modificar_nodoE(self, x, chave, valor):
        if x is not None:
            objeto= x.getData()            
            if chave == int(objeto.numero):
                vendido = float(objeto.vendido) + valor
                objeto.vendido = vendido
                receita = float(objeto.receita) + valor - ((2*valor)/100)
                objeto.receita = receita
                x.setData(objeto)
            if chave < int(objeto.numero):
                return self.modificar_nodoE(x.getLeftNode(), chave, valor)
            else:
                return self.modificar_nodoE(x.getRightNode(), chave, valor)

        #PESQUISA O NODO E FAZ AS MODIFICACOES DA COMPRA
    def modificar_nodo(self, x, chave, valor):
        if x is not None:
            objeto= x.getData()            
            if chave == int(objeto.numero):
                disp = float(objeto.disponivel) - valor
                objeto.disponivel = disp                
                x.setData(objeto)
            if chave < objeto.numero:
                return self.modificar_nodo(x.getLeftNode(), chave, valor)
            else:
                return self.modificar_nodo(x.getRightNode(), chave, valor)

  
        #VARRE A ARVORE EM ORDEM E EXECUTA A FUNCAO PARA CADASTRAR
    def armazenarEmOrdem(self, node):
        "Funcao auxiliar para percuso em Ordem"
        
        if node is not None:
            self.armazenarEmOrdem(node.getLeftNode())
            self.armazena_cartao(node.getData())
            
            self.armazenarEmOrdem(node.getRightNode())


        #CADASTRA CARTAO
    def armazena_cartao(self, dado):
        arquivo='cartoes.txt'
        banco= open(arquivo,"a")
        banco.write(str(dado.numero) + "\t" +  dado.bandeira + "\t" + dado.nome + "\t" + str(dado.limite) +"\t" +str(dado.disponivel)+"\t\n")
        banco.close()
        

        #VARRE A ARVORE EM ORDEM E EXECUTA A FUNCAO PARA CADASTRAR
    def armazenarEmOrdemE(self, node):
        "Funcao auxiliar para percuso em Ordem"
        
        if node is not None:
            self.armazenarEmOrdemE(node.getLeftNode())
            self.armazena_estabelecimento(node.getData())
            
            self.armazenarEmOrdemE(node.getRightNode())

        #CADASTRA ESTABELECIMENTO
    def armazena_estabelecimento(self, dado):
        arquivo='estabelecimentos.txt'
        banco= open(arquivo,"a")
        banco.write(dado.nome + "\t" + dado.numero + "\t" + dado.endereco + "\t" + str(dado.horario[0])+"\t" + str(dado.horario[1]) + "\t" + str(dado.vendido) +"\t" +str(dado.receita)+"\t\n")
        banco.close()
            
